home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / areuh.tar / areuh / assembler / aopc2.c < prev    next >
C/C++ Source or Header  |  1990-10-10  |  10KB  |  514 lines
  1. /*
  2.  * Authors :
  3.  *   Pierre DAVID (pda@masi.ibp.fr or pda@frunip62.bitnet)
  4.  *   Janick TAILLANDIER
  5.  *
  6.  * This program can be freely used or distributed as long as this
  7.  * note is kept.
  8.  *
  9.  * This program is provided "as is".
  10.  */
  11.  
  12. /******************************************************************************
  13.  
  14.                  AREUH ASSEMBLER
  15.  
  16.                 OPCODE PROCESSING (PART 2)
  17.  
  18.  
  19. ******************************************************************************/
  20.  
  21. #include "aglobal.h"
  22. #include "agen.h"
  23.  
  24. extern void l_new_page(), l_print (), ps_line () ;
  25. extern int ascii_len () ;
  26. extern saddr calc_expression () ;
  27.  
  28. int ltok = 255 ;       /* lowest token */
  29. int htok = 0 ;           /* highest token */
  30. int ctok = 0 ;           /* current token */
  31. int ckey = 0 ;           /* current key macro-op */
  32.  
  33.  
  34. /******************************************************************************
  35.  
  36.                    FILE_HEADER
  37.  
  38. synopsis : file_header (modif, type)
  39.        uchar *modif, *line
  40. description : expand a macro-op (LEX or BIN)
  41.  
  42. ******************************************************************************/
  43.  
  44. file_header (modif, type)
  45. uchar *modif, *type ;
  46. {
  47.     uchar line [MAXLEN+1], *pline, limit, c ;
  48.     int i = 0, later = 0 ;
  49.  
  50.     uprc (modif) ;
  51.     strcpy (line, "  NIBASC ") ;
  52.     pline = line + 9 ;
  53.     limit = *modif ;
  54.     if ((limit!='\'')&&(limit!='\\')) error (ERRIFL, "") ; /* inv. file name */
  55.     *pline = limit ;
  56.     pline++ ;
  57.     modif++ ;
  58.     while ((i<=8)&&((c = *modif)!=limit)&&(c))
  59.     {
  60.     i++ ;
  61.     if (!( ((c>='A')&&(c<='Z')) ||
  62.            ((later)&&(c>='0')&&(c<='9')) ) )
  63.         error (ERRIFL, "") ;           /* invalid file name */
  64.     later++ ;
  65.     *pline = c ;
  66.     modif++ ;
  67.     pline++ ;
  68.     }
  69.     if ((i==0)||(i==9)) error (ERRIFL, "") ;
  70.     while (i<8)
  71.     {
  72.     *pline = ' ' ;
  73.     pline++ ;
  74.     i++ ;
  75.     }
  76.     *pline = limit ;
  77.     *(pline+1) = EOL ;
  78.     ps_line (line) ;
  79.  
  80.     strcpy (line, "  NIBHEX ") ;
  81.     strcat (line, type) ;
  82.     ps_line (line) ;
  83.  
  84.     ps_line ("  CON(2) 0") ;                /* copy code / secure code */
  85.  
  86.     for (i=1; i<=5; i++) ps_line ("  CON(2) #00") ;   /* time */
  87.  
  88.     ps_line ("  REL(5) FiLeNd") ;
  89.  
  90.     ctok = ckey = 0 ;
  91. }
  92.  
  93.  
  94. /******************************************************************************
  95.  
  96.                       BSS
  97.  
  98.  
  99. synopsis : void bss (modif)
  100.        char *modif
  101. description : areuh
  102.  
  103. ******************************************************************************/
  104.  
  105. void bss (modif)
  106. uchar *modif ;
  107. {
  108.     saddr val ;
  109.     int i, m ;
  110.  
  111.     val = calc_expression (modif) ;
  112.     if (val < 0L) error (ERRVMD, "BSS") ;                 /* fatal error */
  113.     gen_len = (int) val ;
  114.     if (passnb==2)
  115.     {
  116.     m = (gen_len>18) ? 18 : gen_len ;
  117.     for (i=0; i<m; i++)
  118.         gen_code[i] = '0' ;
  119.     gen_code[m] = EOL ;
  120.     }
  121. }
  122.  
  123.  
  124. void eject ()
  125. {
  126.     l_new_page (1) ;
  127.     print_this_line = 0 ;
  128. }
  129.  
  130.  
  131. void endx ()
  132. {
  133.     running = 0 ;
  134. }
  135.  
  136.  
  137. void list (modif)
  138. uchar *modif ;
  139. {
  140.     int r = 0 ;
  141.     uchar c ;
  142.  
  143.     uprc (modif) ;
  144.     c = *modif++ ;
  145.     if (c=='O')
  146.     {
  147.     c = *modif++ ;
  148.     switch (c)
  149.     {
  150.         case 'N' :
  151.         r = 1 ;
  152.         break ;
  153.         case 'F' :
  154.         c = *modif++ ;
  155.         if (c=='F')  r = 0 ;
  156.         else r = -1 ;
  157.         break ;
  158.         default :
  159.         r = -1 ;
  160.         break ;
  161.     }
  162.     }
  163.     else r = -1 ;
  164.  
  165.     c = *modif ;
  166.     if ((r==-1)||((c!=' ')&&(c!=EOL)&&(c!='\t')))
  167.     error (WRNLST, "") ;   /* invalid LIST argument */
  168.     else cntlist = r * cntlist_ref ;
  169. }
  170.  
  171.  
  172. void title (modif)
  173. uchar *modif ;
  174. {
  175.     if (*l_title==EOL) strcpy (l_title, modif) ;
  176. }
  177.  
  178.  
  179. void stitle (modif)
  180. uchar *modif ;
  181. {
  182.     strcpy (l_stitle, modif) ;
  183.     eject () ;
  184. }
  185.  
  186.  
  187. void lex (modif, line)
  188. uchar *modif, *line ;
  189. {
  190.     switch (passnb)
  191.     {
  192.     case 1 :
  193.         if (linenb!=1) error (ERRLEX, "") ; /* invalid macro LEX or BIN */
  194.         modular = 0 ;
  195.         gen_len = 37 ;
  196.         break ;
  197.     case 2 :
  198.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  199.         file_header (modif, "802E") ;
  200.         print_this_line = 0 ;
  201.         gen_len = 0 ;
  202.         break ;
  203.     }
  204. }
  205.  
  206.  
  207. void id (modif, line)
  208. uchar *modif, *line ;
  209. {
  210.     uchar tmp [MAXLEN+1] ;
  211.  
  212.     switch (passnb)
  213.     {
  214.     case 1 :
  215.         if (modular) error (ERRIMO, "ID") ;
  216.         break ;
  217.     case 2 :
  218.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  219.         sprintf (tmp, "   CON(2) %s", modif) ;
  220.         ps_line (tmp) ;
  221.         sprintf (tmp, "   CON(2) %03d", ltok) ;
  222.         ps_line (tmp) ;
  223.         sprintf (tmp, "   CON(2) %03d", htok) ;
  224.         ps_line (tmp) ;
  225.         ps_line ("   CON(5) 0") ;
  226.         ps_line ("   NIBHEX F") ;
  227.         ps_line ("   REL(4) 1+TxTbSt") ;
  228.         print_this_line = gen_len = 0 ;
  229.         break ;
  230.     } /* du switch */
  231. }
  232.  
  233.  
  234. void msg (modif, line)
  235. uchar *modif, *line ;
  236. {
  237.     uchar tmp [MAXLEN+1] ;
  238.     saddr val ;
  239.  
  240.     switch (passnb)
  241.     {
  242.     case 1 :
  243.         if (modular) error (ERRIMO, "MSG") ;
  244.         break ;
  245.     case 2 :
  246.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  247.         if (((val = calc_expression (modif)) == 0L) || (val == EXP_ERR))
  248.         ps_line ("   CON(4) 0") ;
  249.         else
  250.         {
  251.         sprintf (tmp, "   REL(4) %s", modif) ;
  252.         ps_line (tmp) ;
  253.         }
  254.         print_this_line = gen_len = 0 ;
  255.     } /* du switch */
  256. }
  257.  
  258.  
  259. void poll (modif, line)
  260. uchar *modif, *line ;
  261. {
  262.     uchar tmp [MAXLEN+1] ;
  263.     saddr val ;
  264.  
  265.     switch (passnb)
  266.     {
  267.     case 1 :
  268.         if (modular) error (ERRIMO, "POLL") ;
  269.         break ;
  270.     case 2 :
  271.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  272.         if (((val = calc_expression (modif)) == 0L) || (val == EXP_ERR))
  273.         ps_line ("   CON(5) 0") ;
  274.         else
  275.         {
  276.         sprintf (tmp, "   REL(5) %s", modif) ;
  277.         ps_line (tmp) ;
  278.         }
  279.         print_this_line = gen_len = 0 ;
  280.     } /* du switch */
  281. }
  282.  
  283.  
  284. void entryx (modif, line)
  285. uchar *modif, *line ;
  286. {
  287.     uchar tmp [MAXLEN+1] ;
  288.  
  289.     switch (passnb)
  290.     {
  291.     case 1 :
  292.         if (modular) error (ERRIMO, "ENTRY") ;
  293.         break ;
  294.     case 2 :
  295.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  296.         if (!ctok) ps_line ("   * * * M A I N   T A B L E * * *") ;
  297.         sprintf (tmp, "   CON(3) (TxEn%02d)-(TxTbSt)", ++ctok) ;
  298.         ps_line (tmp) ;
  299.         sprintf (tmp, "   REL(5) %s", modif) ;
  300.         ps_line (tmp) ;
  301.         print_this_line = gen_len = 0 ;
  302.         break ;
  303.     } /* du switch */
  304. }
  305.  
  306.  
  307. void charx (modif, line)
  308. uchar *modif, *line ;
  309. {
  310.     uchar tmp [MAXLEN+1] ;
  311.  
  312.     switch (passnb)
  313.     {
  314.     case 1 :
  315.         if (modular) error (ERRIMO, "CHAR") ;
  316.         break ;
  317.     case 2 :
  318.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  319.         sprintf (tmp, "   CON(1) %s", modif) ;
  320.         ps_line (tmp) ;
  321.         print_this_line = gen_len = 0 ;
  322.         break ;
  323.     }
  324. }
  325.  
  326.  
  327. void key (modif, line)
  328. uchar *modif, *line ;
  329. {
  330.     uchar tmp [MAXLEN+1] ;
  331.  
  332.     switch (passnb)
  333.     {
  334.     case 1 :
  335.         if (modular) error (ERRIMO, "KEY") ;
  336.         if (!ckey) ps_line (" TxTbSt") ;
  337.         sprintf (tmp, " TxEn%02d", ++ckey) ;
  338.         ps_line (tmp) ;
  339.         gen_len = ((ascii_len(modif))*2) + 1 ;
  340.         break ;
  341.     case 2 :
  342.         uprc (modif) ;
  343.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  344.         if (!ckey)
  345.         {
  346.         ps_line ("   * * * T E X T   T A B L E * * *") ;
  347.         ps_line (" TxTbSt") ;
  348.         }
  349.         sprintf (tmp, " TxEn%02d", ++ckey) ;
  350.         ps_line (tmp) ;
  351.         sprintf (tmp, "   CON(1) %02d", ((ascii_len(modif))*2) - 1) ;
  352.         ps_line (tmp) ;
  353.         sprintf (tmp, "   NIBASC %s", modif) ;
  354.         ps_line (tmp) ;
  355.         print_this_line = gen_len = 0 ;
  356.         break ;
  357.     } /* du switch */
  358. }
  359.  
  360.  
  361. void token (modif, line)
  362. uchar *modif, *line ;
  363. {
  364.     uchar tmp [MAXLEN+1] ;
  365.     saddr tok ;
  366.  
  367.     switch (passnb)
  368.     {
  369.     case 1 :
  370.         if (modular) error (ERRIMO, "TOKEN") ;
  371.         tok = calc_expression (modif) ;
  372.         if (tok<ltok) ltok = tok ;
  373.         if (tok>htok) htok = tok ;
  374.         break ;
  375.     case 2 :
  376.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  377.         sprintf (tmp, "   CON(2) %s", modif) ;
  378.         ps_line (tmp) ;
  379.         print_this_line = gen_len = 0 ;
  380.         break ;
  381.     } /* du switch */
  382. }
  383.  
  384.  
  385. void bin (modif, line)
  386. uchar *modif, *line ;
  387. {
  388.     switch (passnb)
  389.     {
  390.     case 1 :
  391.         if (linenb!=1) error (ERRLEX, "") ; /* invalid macro LEX or BIN */
  392.         modular = 0 ;
  393.         gen_len = 37 ;
  394.         break ;
  395.     case 2 :
  396.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  397.         file_header (modif, "402E") ;
  398.         print_this_line = 0 ;
  399.         gen_len = 0 ;
  400.         break ;
  401.     }
  402. }
  403.  
  404.  
  405. void chain (modif, line)
  406. uchar *modif, *line ;
  407. {
  408.     uchar tmp [MAXLEN+1] ;
  409.  
  410.     switch (passnb)
  411.     {
  412.     case 1 :
  413.         if (modular) error (ERRIMO, "CHAIN") ;
  414.         break ;
  415.     case 2 :
  416.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  417.         if (calc_expression (modif) == EXP_ERR)
  418.         ps_line ("   CON(5) -1") ;
  419.         else
  420.         {
  421.         sprintf (tmp, "   REL(5) %s", modif) ;
  422.         ps_line (tmp) ;
  423.         }
  424.         ps_line ("   CON(5) -1") ;
  425.         ps_line ("   NIBHEX 20") ;
  426.         print_this_line = gen_len = 0 ;
  427.         break ;
  428.     }
  429. }
  430.  
  431.  
  432. void endtxt (line)
  433. uchar *line ;
  434. {
  435.     switch (passnb)
  436.     {
  437.     case 1 :
  438.         if (modular) error (ERRIMO, "ENDTXT") ;
  439.         if (!ckey) ps_line (" TxTbSt") ;
  440. /*          if (!ckey) add_label (" TxTbSt", pc, "", LREL, 0) ; */
  441.         gen_len = 3 ;
  442.         break ;
  443.     case 2 :
  444.         if (cntlist) l_print (pc, gen_code, line, F_PC+F_LN+F_TL) ;
  445.         if (!ckey) ps_line (" TxTbSt") ;
  446.         ps_line ("   NIBHEX 1FF") ;
  447.         print_this_line = gen_len = 0 ;
  448.         break ;
  449.     } /* du switch */
  450. }
  451.  
  452. void endifx ()
  453. {
  454.     if (!(in_if || in_else))
  455.     error (WRNIIF, "") ;      /* Invalid conditional structure */
  456.     in_if = in_else = 0 ;
  457.     exec = 1 ;
  458. }
  459.  
  460. void absx (modif)    /* FUTURE USE... */
  461. uchar *modif ;
  462. {
  463. }
  464.  
  465. void rdsymb (modif)
  466. uchar *modif ;
  467. {
  468.     uchar *pmodif ;
  469.  
  470.     if (passnb==1)
  471.     {
  472.     pmodif = modif ;
  473.     while ((*pmodif!=EOL)&&(*pmodif!='\t')&&(*pmodif!=' ')) pmodif++ ;
  474.     *pmodif = EOL ;
  475.     load_file (modif) ;
  476.     }
  477. }
  478.  
  479. void elsex ()
  480. {
  481.     if (!in_if)
  482.     {
  483.     error (WRNIIF, "") ;      /* Invalid conditional structure */
  484.     in_if = in_else = 0 ;
  485.     exec = 1 ;
  486.     }
  487.     else
  488.     {
  489.     in_if = 0 ; in_else = 1 ;
  490.     exec = ! exec ;
  491.     }
  492. }
  493.  
  494. void ifx (modif)
  495. uchar *modif ;
  496. {
  497.     saddr val ;
  498.  
  499.     if (in_if || in_else)
  500.     {
  501.     error (WRNIIF, "") ;      /* Invalid conditional structure */
  502.     in_if = in_else = 0 ;
  503.     exec = 1 ;
  504.     }
  505.     else
  506.     {
  507.     val = calc_expression (modif) ;
  508.     if (val==EXP_EXT)
  509.         error (WRNEXP, "") ;  /* Illegal expression */
  510.     in_if = 1 ; in_else = 0 ;
  511.     exec = (int) val ;
  512.     }
  513. }
  514.